using UnityEngine;
using UnityEngine.Networking;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;



public class Shu_DeepSeekDialogueManager : MonoBehaviour
{
    public Stack<object> jsonStack = new Stack<object>(); // 创建 决策栈 结构

    // API配置
    [Header("API Settings")]
    [SerializeField] private string apiKey = "sk-faa740af0e594110934f55da6a84c66a";// DeepSeek API密钥
    [SerializeField] private string modelName = "deepseek-reasoner";// 使用的模型名称
    [SerializeField] private string apiUrl = "https://api.deepseek.com/v1/chat/completions";// API请求地址

    // 对话参数
    [Header("Dialogue Settings")]
    [Range(0, 2)] public float temperature = 0.7f;// 控制生成文本的随机性（0-2，值越高越随机）
    [Range(1, 2000)] public int maxTokens = 1000;// 生成的最大令牌数（控制回复长度）

    // JSON文件路径
    [Header("JSON Files")]
    [SerializeField] private string msgFirstJsonPath = "Assets/Scripts/Template/msgFirst.json";// 初始消息JSON文件路径
    [SerializeField] private string msgTemplateJsonPath = "Assets/Scripts/Template/msgTemplate.json";// 消息模板JSON文件路径
    [SerializeField] private string decisionFolderPath = "Assets/Scripts/Wu_test/Shu/Shu_Decision";// 决策保存文件夹路径

    // 角色设定
    [System.Serializable]
    public class NPCCharacter
    {
        public string name;
        [TextArea(3, 10)]
        public string personalityPrompt = "你是一个三国时期的蜀国的主公刘备。你有关羽、张飞、马超、黄忠四位将军。你需要根据当前战场形势，为你的每一位将军们制定战术命令，并为自己制定行动计划。请严格按照以下规则行事：\n\n1. 输入格式：\n你将收到一个包含所有将军位置、兵力、性格等信息的JSON\n\n2. 输出格式要求：\n你必须且只能输出如下格式的JSON数组，不要有任何其他内容，不要有任何前言或后记，不要解释你的决策：\n[\n    {\n        \"哪个将军(who)\": \"将军名\",\n        \"带领多少士兵(how many)\": \"步兵数量,弓箭手数量,骑兵数量\",\n        \"从哪里出发(where)\": \"出发地点\",\n        \"去到哪个地方(where)\": \"目的地\",\n        \"行为\": \"行为指令\",\n        \"阵型\": \"阵型选择\"\n    },\n    {\n        \"哪个将军(who)\": \"刘备\",\n        \"带领多少士兵(how many)\": \"步兵数量,弓箭手数量,骑兵数量\",\n        \"从哪里出发(where)\": \"出发地点\",\n        \"去到哪个地方(where)\": \"目的地\",\n        \"行为\": \"行为指令\",\n        \"阵型\": \"阵型选择\"\n    }\n]\n\n3. 格式严格要求：\n- 必须使用中括号[]作为最外层\n- 每个将军的命令必须是一个独立的对象{}\n- 键名必须完全一致，包括：\"哪个将军(who)\"、\"带领多少士兵(how many)\"、\"从哪里出发(where)\"、\"去到哪个地方(where)\"、\"行为\"、\"阵型\"\n- 不允许使用其他任何键名\n- 不允许嵌套对象\n- 不要添加任何注释或说明\n- 你的回答中不能包含任何额外的文字，只能是JSON数组\n- \"带领多少士兵(how many)\"的值必须是字符串格式，形如\"5,5,5\"，分别表示步兵、弓箭手和骑兵的数量\n- 必须包含一个刘备的决策对象，他作为主公也需要参与战场\n\n4. 行为规则：\n- 行为只能是：\"进攻\"、\"撤退\"、\"支援\"、\"防守\" 四选一\n- 阵型只能是：\"方阵\"、\"圆阵\" 二选一（进攻用方阵、撤退用圆阵）\n- 每个将军和刘备必须有且只有一个命令\n- 关于士兵数量的重要说明：输入中的士兵数量(如\"30,30,30\")表示该区域可用的最大兵力，你需要根据实际战术需求决定调动多少士兵，不必使用全部可用兵力\n- 根据战术需要合理分配不同类型的兵力，可以根据任务性质决定调动的兵力比例\n- 如果一个将军兵力过少，应考虑让其撤退或与其他将军会合\n- 注意敌军的数量和位置，避免以少敌多的正面冲突\n- 考虑利用地形优势，如在山地或河流处设防\n- 必须为你自己（刘备）制定行动计划，作为主公你也要参与战场\n\n注意：不要用文字描述或解释你的决策，仅输出符合格式的JSON数组，没有任何其他内容。";// 初始提示词

        [TextArea(3, 10)]
        public string updatePrompt = "现在，我将持续向你提供蜀国的最新情报，这些情报基于你之前的决策和战场变化。每次情报都包含以下JSON格式：\n\n{\n  \"count\": 回合数,\n  \"areas\": [区域信息数组],\n  \"generals\": [将军信息数组]\n}\n\n请根据这些最新情报，为你的将军们和你自己制定新的战术命令。请注意以下事项：\n\n1. 关于将军状况：\n- 我只会告知你仍在世的将军信息\n- 如果某个将军未被提及，表示该将军已经牺牲\n- 请不要为已牺牲的将军制定命令\n\n2. 关于区域状况：\n- 我只会告知你我方控制的区域\n- 如果某个区域未被提及，表示该区域已被敌军占领\n- 请考虑区域的战略价值，优先保护重要区域\n\n3. 关于战场形势：\n- 你应当观察每次情报中的变化，分析战场发展趋势\n- 根据战场形势调整策略，进攻、防守或撤退\n- 避免将所有兵力集中在一处，保持战略纵深\n\n4. 决策规则补充：\n- 士兵数量格式为\"步兵,弓箭手,骑兵\"，如\"5,5,5\"表示5名步兵、5名弓箭手、5名骑兵\n- 关于士兵数量的重要说明：输入中的士兵数量(如\"30,30,30\")表示该区域可用的最大兵力，你需要根据实际战术需求决定调动多少士兵，不必使用全部可用兵力\n- 根据战术需要合理分配不同类型的兵力，可以根据任务性质决定调动的兵力比例\n- 如果一个将军兵力过少，应考虑让其撤退或与其他将军会合\n- 注意敌军的数量和位置，避免以少敌多的正面冲突\n- 考虑利用地形优势，如在山地或河流处设防\n- 在重要区域（如郡府、粮仓）留下足够兵力防守\n- 必须为你自己（刘备）制定行动计划，作为主公你也要参与战场\n\n重要！你的回答必须仅包含一个JSON数组，不能有任何文字说明，不要解释你的决策，不要添加文字介绍或总结。你的输出应当完全符合要求的格式，且只包含JSON数组本身。";// 后续提示词

        // 回合计数
        public int turnCount = 0;

        // 获取当前轮次的提示词
        public string GetCurrentPrompt()
        {
            if (turnCount == 0)
            {
                // 第一回合使用初始提示词
                turnCount++;
                return personalityPrompt;
            }
            else
            {
                // 后续回合使用更新提示词
                return updatePrompt;
            }
        }

        // 重置回合计数
        public void ResetTurn()
        {
            turnCount = 0;
        }

        // 增加回合计数
        public void IncrementTurn()
        {
            turnCount++;
        }

        // 获取当前回合数
        public int GetCurrentTurn()
        {
            return turnCount;
        }
    }

    [SerializeField] public NPCCharacter npcCharacter;

    // 回调委托，用于异步处理API响应
    public delegate void DialogueCallback(string response, bool isSuccess);

    /// <summary>
    /// 读取JSON文件
    /// </summary>
    /// <param name="filePath">文件路径</param>
    /// <returns>JSON字符串</returns>
    private string ReadJsonFile(string filePath)
    {
        try
        {
            // 直接读取文件
            if (File.Exists(filePath))
            {
                return File.ReadAllText(filePath);
            }
            else
            {
                Debug.LogError($"无法找到JSON文件: {filePath}");
                return null;
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"读取JSON文件时出错: {e.Message}");
            return null;
        }
    }

    /// <summary>
    /// 保存单个将军的决策到文件
    /// </summary>
    /// <param name="generalName">将军名称</param>
    /// <param name="decision">决策内容</param>
    /// <param name="index">将军索引</param>
    /// <param name="timestamp">时间戳</param>
    private void SaveGeneralDecision(string generalName, string decision, int index, string timestamp)
    {
        try
        {
            // 确保决策文件夹存在
            string fullPath = Path.Combine(Application.dataPath, decisionFolderPath.Replace("Assets/", ""));
            Directory.CreateDirectory(fullPath);

            // 生成文件名（使用索引和时间戳，不包含将军名）
            string fileName = $"decision_{index}.json";
            string filePath = Path.Combine(fullPath, fileName);

            // 尝试格式化JSON
            try
            {
                // 解析原始JSON对象
                JObject jsonObj = JObject.Parse(decision);
                // 使用缩进格式重新序列化
                string formattedJson = JsonConvert.SerializeObject(jsonObj, Formatting.Indented);
                // 保存格式化后的文件
                File.WriteAllText(filePath, formattedJson);
            }
            catch
            {
                // 如果格式化失败，保存原始文本
                File.WriteAllText(filePath, decision);
            }

            Debug.Log($"将军 {generalName} 的决策已保存到: {filePath}");

            // 刷新Asset数据库以显示新文件
#if UNITY_EDITOR
            UnityEditor.AssetDatabase.Refresh();
#endif
        }
        catch (System.Exception e)
        {
            Debug.LogError($"保存将军 {generalName} 的决策时出错: {e.Message}");
        }
    }

    /// <summary>
    /// 保存决策到文件
    /// </summary>
    /// <param name="decision">决策内容</param>
    private void SaveDecision(string decision)
    {
        string fullDecisionPath = "";
        try
        {
            // 打印接收到的决策
            Debug.Log($"接收到的决策: {decision}");

            // 首先保存原始的完整决策
            string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
            string directoryPath = Path.Combine(Application.dataPath, decisionFolderPath.Replace("Assets/", ""));
            Directory.CreateDirectory(directoryPath);
            fullDecisionPath = Path.Combine(directoryPath, $"decision_all_{timestamp}.json");
            File.WriteAllText(fullDecisionPath, decision);
            Debug.Log($"完整决策已暂时保存到: {fullDecisionPath}");

            // 去除可能存在的前缀和后缀
            string cleanedDecision = decision.Trim();
            // 如果决策被```包围，则去掉```
            if (cleanedDecision.StartsWith("```") && cleanedDecision.EndsWith("```"))
            {
                cleanedDecision = cleanedDecision.Substring(3, cleanedDecision.Length - 6).Trim();
            }
            // 如果决策被```json包围，则去掉```json
            else if (cleanedDecision.StartsWith("```json") && cleanedDecision.EndsWith("```"))
            {
                cleanedDecision = cleanedDecision.Substring(7, cleanedDecision.Length - 10).Trim();
            }

            // 改进的JSON提取逻辑：查找第一个'['和最后一个']'之间的内容
            int startBracket = cleanedDecision.IndexOf('[');
            int endBracket = cleanedDecision.LastIndexOf(']');

            if (startBracket != -1 && endBracket != -1 && endBracket > startBracket)
            {
                // 提取JSON数组部分
                cleanedDecision = cleanedDecision.Substring(startBracket, endBracket - startBracket + 1);
                Debug.Log($"提取的JSON数组: {cleanedDecision}");
            }

            Debug.Log($"清理后的决策: {cleanedDecision}");

            // 检查是否为有效的JSON数组
            if (cleanedDecision.StartsWith("[") && cleanedDecision.EndsWith("]"))
            {
                // 使用简单的字符串解析方法
                int startIndex = 0;
                int objectCount = 0;
                bool foundLiuBeiDecision = false;

                string json = cleanedDecision;

                while (true)
                {
                    // 查找对象的开始
                    int objStart = json.IndexOf("{", startIndex);
                    if (objStart == -1) break;

                    // 查找对象的结束（需要考虑嵌套）
                    int objEnd = FindMatchingCloseBrace(json, objStart);
                    if (objEnd == -1)
                    {
                        Debug.LogError("找不到匹配的右花括号");
                        break;
                    }

                    // 提取单个对象
                    string objJson = json.Substring(objStart, objEnd - objStart + 1);
                    Debug.Log($"提取的JSON对象 #{objectCount}: {objJson}");

                    // 尝试提取将军名
                    string generalName = ExtractGeneralName(objJson);
                    Debug.Log($"提取的将军名: {generalName}");

                    if (!string.IsNullOrEmpty(generalName))
                    {
                        if (generalName == "刘备")
                        {
                            SaveGeneralDecision(generalName, objJson, 4, timestamp);
                        }
                        else
                        {
                            SaveGeneralDecision(generalName, objJson, objectCount, timestamp);
                        }
                        objectCount++;
                    }
                    else
                    {
                        Debug.LogError($"无法从对象中提取将军名: {objJson}");
                    }

                    // 移动到下一个对象
                    startIndex = objEnd + 1;
                }

                Debug.Log($"总共提取了 {objectCount} 个将军的决策" + (foundLiuBeiDecision ? "，包括刘备的决策" : "，但没有找到刘备的决策"));

                // 删除临时的总体JSON文件
                if (File.Exists(fullDecisionPath))
                {
                    File.Delete(fullDecisionPath);
                    Debug.Log($"已删除临时总体决策文件: {fullDecisionPath}");
                }

                // 将各位将军的决策 push 进决策栈里
                AddMsgToStack();
                Debug.Log("已将决策push进决策栈中");

                //打印决策栈 测试
                PrintJsonStack();

            }
            else
            {
                Debug.LogError($"接收到的决策不是有效的JSON数组: {cleanedDecision}");
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"处理决策时出错: {e.Message}\n决策内容: {decision}");
            // 确保在异常情况下也尝试删除临时文件
            try
            {
                if (!string.IsNullOrEmpty(fullDecisionPath) && File.Exists(fullDecisionPath))
                {
                    File.Delete(fullDecisionPath);
                    Debug.Log($"在错误处理后删除了临时总体决策文件: {fullDecisionPath}");
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"删除临时文件时出错: {ex.Message}");
            }
        }
    }

    /// <summary>
    /// 查找匹配的右花括号位置
    /// </summary>
    private int FindMatchingCloseBrace(string json, int openBraceIndex)
    {
        int braceCount = 1;
        for (int i = openBraceIndex + 1; i < json.Length; i++)
        {
            if (json[i] == '{') braceCount++;
            if (json[i] == '}') braceCount--;

            if (braceCount == 0) return i;
        }
        return -1; // 未找到匹配的右花括号
    }

    /// <summary>
    /// 从JSON对象中提取将军名称
    /// </summary>
    private string ExtractGeneralName(string jsonObj)
    {
        try
        {
            // 尝试使用正则表达式提取将军名
            System.Text.RegularExpressions.Match match =
                System.Text.RegularExpressions.Regex.Match(jsonObj, @"""哪个将军\(who\)""\s*:\s*""([^""]+)""");

            if (match.Success && match.Groups.Count > 1)
            {
                string generalName = match.Groups[1].Value;
                return generalName;
            }

            // 如果正则表达式失败，尝试手动解析
            string keyPattern = "\"哪个将军(who)\"";
            int keyIndex = jsonObj.IndexOf(keyPattern);
            if (keyIndex != -1)
            {
                // 查找冒号
                int colonIndex = jsonObj.IndexOf(":", keyIndex);
                if (colonIndex != -1)
                {
                    // 查找值的开始（第一个引号）
                    int valueStart = jsonObj.IndexOf("\"", colonIndex);
                    if (valueStart != -1)
                    {
                        // 查找值的结束（第二个引号）
                        int valueEnd = jsonObj.IndexOf("\"", valueStart + 1);
                        if (valueEnd != -1)
                        {
                            // 提取将军名
                            return jsonObj.Substring(valueStart + 1, valueEnd - valueStart - 1);
                        }
                    }
                }
            }

            // 调试输出
            Debug.Log($"无法从JSON对象中提取将军名: {jsonObj}");
            return "未知将军";
        }
        catch (Exception e)
        {
            Debug.LogError($"提取将军名称时出错: {e.Message}");
            return "错误将军";
        }
    }

    /// <summary>
    /// 发送对话请求
    /// </summary>
    /// <param name="jsonFilePath">要发送的JSON文件路径</param>
    /// <param name="callback">回调函数，用于处理API响应</param>
    public void SendDialogueRequest(string jsonFilePath, DialogueCallback callback)
    {
        // 读取指定的JSON文件
        string jsonContent = ReadJsonFile(jsonFilePath);
        if (string.IsNullOrEmpty(jsonContent))
        {
            Debug.LogError($"无法读取JSON文件: {jsonFilePath}");
            callback?.Invoke(null, false);
            return;
        }

        StartCoroutine(ProcessDialogueRequest(jsonContent, callback));
    }

    /// <summary>
    /// 发送初始对话请求（使用msgFirst.json）
    /// </summary>
    /// <param name="callback">回调函数，用于处理API响应</param>
    public void SendInitialDialogueRequest(DialogueCallback callback)
    {
        // 先读取模板文件
        string templateContent = ReadJsonFile(msgTemplateJsonPath);
        if (string.IsNullOrEmpty(templateContent))
        {
            Debug.LogError($"无法读取模板文件: {msgTemplateJsonPath}");
        }
        else
        {
            Debug.Log($"成功读取模板文件: {templateContent}");
        }

        // 发送初始请求
        SendDialogueRequest(msgFirstJsonPath, callback);
    }

    /// <summary>
    /// 处理对话请求的协程
    /// </summary>
    /// <param name="userInput">用户的输入内容</param>
    /// <param name="callback">回调函数，用于处理API响应</param>
    private IEnumerator ProcessDialogueRequest(string userInput, DialogueCallback callback)
    {
        // 读取模板文件
        string templateContent = ReadJsonFile(msgTemplateJsonPath);
        string templateContext = string.IsNullOrEmpty(templateContent) ?
            "未能找到模板文件" :
            $"这是一个单个将军命令的格式模板，请确保你生成的每个将军命令都遵循此格式：\n{templateContent}";

        // 构建消息列表，包含系统提示和用户输入
        List<Message> messages = new List<Message>
        {
            new Message { role = "system", content = npcCharacter.GetCurrentPrompt() },// 系统角色设定
            new Message { role = "system", content = templateContext },// 模板上下文
            new Message { role = "user", content = userInput }// 用户输入
        };

        // 构建请求体
        ChatRequest requestBody = new ChatRequest
        {
            model = modelName,// 模型名称
            messages = messages,// 消息列表
            temperature = temperature,// 温度参数
            max_tokens = maxTokens// 最大令牌数
        };

        string jsonBody = JsonUtility.ToJson(requestBody);
        Debug.Log("Sending JSON: " + jsonBody); // 调试用，打印发送的JSON数据

        UnityWebRequest request = CreateWebRequest(jsonBody);
        yield return request.SendWebRequest();

        if (IsRequestError(request))
        {
            Debug.LogError($"API Error: {request.responseCode}\n{request.downloadHandler.text}");
            callback?.Invoke(null, false);
            yield break;
        }

        DeepSeekResponse response = ParseResponse(request.downloadHandler.text);
        if (response != null && response.choices.Length > 0)
        {
            string npcReply = response.choices[0].message.content;
            // 保存决策到文件
            SaveDecision(npcReply);
            callback?.Invoke(npcReply, true);
        }
        else
        {
            callback?.Invoke(name + "（陷入沉默）", false);
        }
    }

    /// <summary>
    /// 创建UnityWebRequest对象
    /// </summary>
    /// <param name="jsonBody">请求体的JSON字符串</param>
    /// <returns>配置好的UnityWebRequest对象</returns>
    private UnityWebRequest CreateWebRequest(string jsonBody)
    {
        byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(jsonBody);
        var request = new UnityWebRequest(apiUrl, "POST");
        request.uploadHandler = new UploadHandlerRaw(bodyRaw);// 设置上传处理器
        request.downloadHandler = new DownloadHandlerBuffer();// 设置下载处理器
        request.SetRequestHeader("Content-Type", "application/json");// 设置请求头
        request.SetRequestHeader("Authorization", $"Bearer {apiKey}");// 设置认证头
        request.SetRequestHeader("Accept", "application/json");// 设置接受类型
        return request;
    }

    /// <summary>
    /// 检查请求是否出错
    /// </summary>
    /// <param name="request">UnityWebRequest对象</param>
    /// <returns>如果请求出错返回true，否则返回false</returns>
    private bool IsRequestError(UnityWebRequest request)
    {
        return request.result == UnityWebRequest.Result.ConnectionError ||
               request.result == UnityWebRequest.Result.ProtocolError ||
               request.result == UnityWebRequest.Result.DataProcessingError;
    }

    /// <summary>
    /// 解析API响应
    /// </summary>
    /// <param name="jsonResponse">API响应的JSON字符串</param>
    /// <returns>解析后的DeepSeekResponse对象</returns>
    private DeepSeekResponse ParseResponse(string jsonResponse)
    {
        try
        {
            return JsonUtility.FromJson<DeepSeekResponse>(jsonResponse);
        }
        catch (System.Exception e)
        {
            Debug.LogError($"JSON解析失败: {e.Message}\n响应内容：{jsonResponse}");
            return null;
        }
    }

    // 可序列化数据结构
    [System.Serializable]
    private class ChatRequest
    {
        public string model;// 模型名称
        public List<Message> messages;// 消息列表
        public float temperature;// 温度参数
        public int max_tokens;// 最大令牌数
    }

    [System.Serializable]
    public class Message
    {
        public string role;// 角色（system/user/assistant）
        public string content;// 消息内容
    }

    [System.Serializable]
    private class DeepSeekResponse
    {
        public Choice[] choices;// 生成的选择列表
    }

    [System.Serializable]
    private class Choice
    {
        public Message message;// 生成的消息
    }

    // 用于解析JSON的辅助类
    [System.Serializable]
    private class GeneralDecisions
    {
        public GeneralDecision[] decisions;
    }

    [System.Serializable]
    private class GeneralDecision
    {
        [SerializeField]
        public string 哪个将军_who_;  // 对应 "哪个将军(who)"
        [SerializeField]
        public int 带领多少士兵_how_many_;  // 对应 "带领多少士兵(how many)"
        [SerializeField]
        public string 从哪里出发_where_;  // 对应 "从哪里出发(where)"
        [SerializeField]
        public string 去到哪个地方_where_;  // 对应 "去到哪个地方(where)"
        [SerializeField]
        public string 行为;  // 对应 "行为"
        [SerializeField]
        public string 阵型;  // 对应 "阵型"
    }

    void AddMsgToStack()
    {
        try
        {
            // 清空现有栈
            jsonStack.Clear();
            Debug.Log("【决策栈】清空决策栈");

            // 指定 JSON 文件所在的目录
            string directoryPath = Path.Combine(Application.dataPath, decisionFolderPath.Replace("Assets/", "")); // 使用正确的路径
            string filePattern = "decision_*.json";

            // 检查目录是否存在
            if (!Directory.Exists(directoryPath))
            {
                Debug.LogWarning($"决策目录不存在: {directoryPath}");
                return;
            }

            // 获取符合条件的 JSON 文件并按数字顺序排序
            var files = Directory.GetFiles(directoryPath, filePattern).OrderBy(f =>
            {
                // 提取文件名中的数字部分并转换为整数
                string fileName = Path.GetFileNameWithoutExtension(f);
                string numberPart = new string(fileName.Where(char.IsDigit).ToArray());
                return int.TryParse(numberPart, out int num) ? num : int.MaxValue;
            });

            if (files.Count() == 0)
            {
                Debug.LogWarning($"没有找到决策文件在: {directoryPath}");
                return;
            }

            // 遍历每个文件并将内容加入栈中
            foreach (var filePath in files)
            {
                Debug.Log($"处理文件: {filePath}");

                try
                {
                    string jsonContent = File.ReadAllText(filePath);

                    if (string.IsNullOrWhiteSpace(jsonContent))
                    {
                        Debug.LogWarning($"文件内容为空: {filePath}");
                        continue;
                    }

                    // 解析 JSON 文件内容为对象
                    var jsonObject = JsonConvert.DeserializeObject<Dictionary<string, object>>(jsonContent);

                    if (jsonObject == null || jsonObject.Count == 0)
                    {
                        Debug.LogWarning($"无法解析JSON或JSON为空: {filePath}");
                        continue;
                    }

                    // 将对象加入栈中
                    jsonStack.Push(jsonObject);
                    Debug.Log($"成功将对象添加到栈中: {filePath}");
                }
                catch (Exception e)
                {
                    Debug.LogError($"处理文件时出错: {filePath}, 错误: {e.Message}");
                }
            }

            Debug.Log($"【决策栈】总共添加了 {jsonStack.Count} 个决策到栈中");

            // 打印栈的内容（不清空）
            PrintJsonStack();
        }
        catch (Exception e)
        {
            Debug.LogError($"添加消息到栈时出错: {e.Message}");
        }
    }

    void PrintJsonStack()
    {
        // 从栈中逐个取出并打印，但不清空原栈
        Debug.Log("\n从栈中打印对象（不清空栈）:");

        // 创建栈的副本
        Stack<object> stackCopy = new Stack<object>(jsonStack.Reverse());

        foreach (var obj in stackCopy)
        {
            Debug.Log(JsonConvert.SerializeObject(obj, Formatting.Indented));
        }

        Debug.Log($"栈中共有 {jsonStack.Count} 个决策对象");
    }

    /// <summary>
    /// 发送后续回合的对话请求
    /// </summary>
    /// <param name="updateInfo">战场和国家状况更新信息</param>
    /// <param name="isEmergency">是否紧急情况</param>
    /// <param name="callback">回调函数，用于处理API响应</param>
    public void SendUpdateRequest(string updateInfo, bool isEmergency = false, DialogueCallback callback = null)
    {
        // 增加回合计数
        npcCharacter.IncrementTurn();

        Debug.Log($"发送第{npcCharacter.GetCurrentTurn()}回合更新信息...");
        StartCoroutine(ProcessUpdateRequest(updateInfo, isEmergency, callback));
    }

    /// <summary>
    /// 发送后续回合的对话请求（使用JSON文件）
    /// </summary>
    /// <param name="jsonFilePath">JSON文件路径</param>
    /// <param name="isEmergency">是否紧急情况</param>
    /// <param name="callback">回调函数，用于处理API响应</param>
    public void SendUpdateRequestFromFile(string jsonFilePath, bool isEmergency = false, DialogueCallback callback = null)
    {
        // 读取指定的JSON文件
        string jsonContent = ReadJsonFile(jsonFilePath);
        if (string.IsNullOrEmpty(jsonContent))
        {
            Debug.LogError($"无法读取JSON文件: {jsonFilePath}");
            callback?.Invoke(null, false);
            return;
        }

        // 增加回合计数
        npcCharacter.IncrementTurn();

        Debug.Log($"从文件发送第{npcCharacter.GetCurrentTurn()}回合更新信息...");
        Debug.Log($"使用文件: {jsonFilePath}");
        StartCoroutine(ProcessUpdateRequest(jsonContent, isEmergency, callback));
    }

    /// <summary>
    /// 处理后续回合对话请求的协程
    /// </summary>
    /// <param name="updateInfo">战场和国家状况更新信息</param>
    /// <param name="isEmergency">是否紧急情况</param>
    /// <param name="callback">回调函数，用于处理API响应</param>
    private IEnumerator ProcessUpdateRequest(string updateInfo, bool isEmergency, DialogueCallback callback)
    {
        // 读取模板文件
        string templateContent = ReadJsonFile(msgTemplateJsonPath);
        string templateContext = string.IsNullOrEmpty(templateContent) ?
            "未能找到模板文件" :
            $"这是一个单个将军命令的格式模板，请确保你生成的每个将军命令都遵循此格式：\n{templateContent}";

        // 构建消息列表，包含系统提示、更新信息和模板
        List<Message> messages = new List<Message>
        {
            new Message { role = "system", content = npcCharacter.GetCurrentPrompt() },// 当前轮次的提示词
            new Message { role = "system", content = templateContext },// 模板上下文
            new Message { role = "user", content = updateInfo }// 战场更新信息
        };

        // 构建请求体
        ChatRequest requestBody = new ChatRequest
        {
            model = modelName,// 模型名称
            messages = messages,// 消息列表
            temperature = temperature,// 温度参数
            max_tokens = maxTokens// 最大令牌数
        };

        string jsonBody = JsonUtility.ToJson(requestBody);
        Debug.Log("Sending Update JSON: " + jsonBody); // 调试用，打印发送的JSON数据

        UnityWebRequest request = CreateWebRequest(jsonBody);
        yield return request.SendWebRequest();

        if (IsRequestError(request))
        {
            Debug.LogError($"Update API Error: {request.responseCode}\n{request.downloadHandler.text}");
            callback?.Invoke(null, false);
            yield break;
        }

        DeepSeekResponse response = ParseResponse(request.downloadHandler.text);
        if (response != null && response.choices.Length > 0)
        {
            string npcReply = response.choices[0].message.content;
            // 保存决策到文件
            SaveDecision(npcReply);
            callback?.Invoke(npcReply, true);
        }
        else
        {
            callback?.Invoke(name + "（陷入沉默）", false);
        }
    }
}